Repository navigation
Conversation
tests/task-planner brings task into each situation its planner tells apart (E-stop, off, Manual, MDI idle and running, Auto idle, reading, waiting and paused) and sends it every command emcTaskPlan() handles, one at a time, plus one it has no case for. From task's own debug output it records, for each, whether the planner issued the command, queued it for later, refused it or handled it itself, and what situation the command left task in. The table is compared with tests/task-planner/ expected, which is the behaviour of today's planner. A change to the planner that is not meant to change behaviour leaves the table as it is; one that is shows up as a diff of it. The commands come from test_task_probe, a small NML client that sends any of them with arguments that change as little as possible. It is built for run-in-place only and not installed; the test skips without it.
emcTaskPlan() found its command itself: it compared emcCommand's serial number with the echoed one to tell a new command from none, and allow_while_idle_type() read the command's type from the NML buffer once more. Have the main loop make that decision and pass the new command, or NULL, and use only that inside the planner. This is what lets a command reach the planner by another way than the NML buffer. No change in behaviour: tests/task-planner is unchanged.
The planner's tables repeated the commands each passes straight to emcTaskIssueCommand(): 22 accepted in any state, three more only while the machine is off, twelve once it is on, the spindle commands unless a program is reading or waiting, the program and I/O commands unless one runs, and so on. isImmediate() now says this once, by the state, mode and interpreter state task is in, and each table keeps only what is special to it and its own refusal. allow_while_idle_type() is part of it now, and the three tool commands share queueToolCommand(). No change in behaviour: tests/task-planner is unchanged, and fails if spindle orient is let through in Manual, as an example of a slip.
Task gets a HAL component, "task", with the status pins of halui that have no equivalent elsewhere: the task mode and whether motion is in joint mode, the interpreter state, optional stop and block delete, the override and max-velocity values, the soft limits and override-limits of each joint, each axis' Cartesian feedback and relative (DRO) position, the tool diameter and units-per-mm. Their names are halui's under "task." instead of "halui.". They are updated once per task cycle from task's own status, so they are current in the same cycle, where halui's lag by its poll. The component is created before inihal is ready, so that the HAL files, which the linuxcnc script runs as soon as inihal is, can connect its pins, as they can halui's. The axes and spindles are therefore read from the INI file, the way task sets motion up with them. tests/task-hal-pins connects some of the pins in a HAL file, and compares every one of them with halui's pin in manual, teleop, MDI with offsets and tools, with overrides, and while a program runs and is paused.
Task exports halui's command input pins: machine on/off, E-stop reset, teleop/joint mode, mist and flood, program run/pause/resume/step/stop, abort, optional stop and block delete, home-all (with [JOINT_0]HOME_SEQUENCE, like halui), home and unhome of each joint, and start/stop/forward/reverse/increase/decrease/brake of each spindle. Like halui's they act on the rising edge, spindle increase and decrease also on the falling one, and send the same commands. halui's mode.manual, .auto and .mdi pins are left out: task's modes are to follow what task runs rather than be set. program.run switches to Auto first, as halui does. The commands do not go through NML. emcTaskQueueInternalCommand() queues them, and the main loop hands one to emcTaskPlan() on each cycle without a new NML command. They leave the echo serial number alone, and a refused one is reported on the error channel only: it does not turn the status of the UI's last command into ERROR, nor does a successful one clear that command's error. tests/task-hal-inputs pulses each pin, without halui, and checks both; it also sets one of the pins from a HAL file.
Three halui pins have a counterpart in iocontrol that is not quite the same signal, so a configuration could not just be renamed to it: - task.estop.is-activated: iocontrol.0.user-enable-out is its inverse. - task.estop.activate: iocontrol.0.emc-enable-in is a level that holds the machine in E-stop; this is an edge that puts it there once. - task.tool.number: iocontrol.0.tool-number is signed, halui's unsigned. With these, each halui pin that motion, iocontrol or task now covers has exactly one pin to be renamed to.
Contributor
|
EMC_JOG_ABS, EMC_JOINT_HALT, EMC_JOINT_SET_FERROR, EMC_JOINT_SET_MIN_FERROR, EMC_JOINT_SET_HOMING_PARAMS, EMC_TRAJ_SET_VELOCITY and EMC_TRAJ_SET_ACCELERATION, with their classes, task's handling of them and their rows in the planner table. emcJogAbs() had no other caller.
… of checkInterpList() checkInterpList() lost its limit checks long ago and always returned 0; it now only shows the operator errors of the lines it drops. task read [TASK]MDI_QUEUED_COMMANDS and never used it.
42 file-level pointers each held the cast for one case. Those used once are folded into the call; the others are declared in their case.
emcTaskCheckPreconditions() and emcTaskCheckPostconditions() become commandWaits(), and the STEPPING_CHECK macro becomes steppingHolds(). The table says what the two switches said, command for command.
emcTaskPlan() works out the situation once, then a command is handled by the planner itself (planSpecial()), passed straight through (isImmediate()) or refused (refuse()). The planner table is unchanged.
With EMC_JOG_ABS and emcJogAbs() gone the handler had no caller. In teleop it was not absolute either: axis_jog_abs() added the target to the current position.
test.sh exited 0 without the probe and checkresult then failed for lack of probes, in every package build. A skip file is what runtests has for this. The loop variable shellcheck flagged as unused (SC2034) is now _.
Axes can be jogged (keyboard, AXIS, halui, linuxcncrsh, wheel) while a program or MDI command is paused, M0/M1 included, once the pause has stopped the motion. Joints cannot. Motion keeps the paused program position and adds a per-axis pause offset on top of it, as the external offsets are added (axis_pause_*() in axis.c), within the soft limits. The queued moves and the interpreter are untouched. On resume or step, do_pause_resume() (control.c): - puts the spindles back as they were at the pause (state, direction, speed, CSS) and waits for them to be at speed; - returns the axes: the ones not in [TRAJ]PAUSE_RETURN_LAST (default Z) together in a straight line, then those, at the axis limits, and sets the offsets to exactly zero; - then resumes or steps. Task restores mist and flood. Pausing during the return stops it there. An abort keeps the machine where it was jogged to: the planner takes the offsets into its position. Reverse run is refused while jogged away. Status: pause_offset, pause_jog_ok and pause_returning in EMC_MOTION_STAT and Python. Task accepts axis jogs while paused (planSpecial()), halui and linuxcncrsh send them, AXIS enables its jog and spindle controls (not homing) and does not ask for Manual mode while paused. This is the work from LinuxCNC#4700, for a task that still has modes: - the mode stays Auto or MDI during the pause; nothing switches it; - in coordinated mode without a pause (MDI mode, idle) a jog still does nothing and reports nothing; - the planner table changes in one cell: EMC_JOG_STOP is issued while Auto is paused; - no absolute jog, which this branch has removed. Tests: new tests/jog-while-paused; motion-logger expectations gain the SET_PAUSE_RETURN_LAST startup command.
Manual, MDI and Auto are no longer modes a user interface switches between. Task tracks what it runs (idle, a program, MDI) and reports the mode from that: Auto while a program runs or is paused, MDI while MDI commands run, Manual otherwise. - While idle task accepts jogs, homing, MDI commands and program runs. Starting a run checks homing, an open program and that no jog (including a wheel jog) is active, switches motion to coordinated mode and re-syncs the interpreter; nothing leaves interp_list until motion is in coordinated mode. When the run ends motion goes back to the joint or world mode it had before, so wheel jogs work whenever nothing runs. - The planner chooses its command table by what runs: idle (the old Manual and Auto-idle tables merged), program (unchanged), MDI running (jogs and joint/world switching refused). - EMC_TASK_SET_MODE is accepted in any state and does nothing. - halui: halui.mode.manual, .mdi and .auto do nothing, the is-* pins show the derived mode, MDI commands go straight to task. User interfaces that switch pages on the mode keep working through a per-UI view mode: Python mode(), Tcl emc_mode and linuxcncrsh set mode (per connection) record the page asked for, and task_mode / get mode report it while task is idle. AXIS loses its "coordinated while Manual, force teleop" kick and the dead tab-raise code. Behaviour changes, documented in updating-linuxcnc: switching to Manual no longer aborts a running MDI command; a run started from Manual runs the program; a run with no program open is refused; the parameter file is saved at the start of every MDI command from idle. Tests: new tests/task-modeless; halui/mdi rewritten for the new semantics; g28.2/invalid-pword waits for motion to leave coordinated mode; motion-logger, M99, interp_initcode and linuxcncrsh expectations updated for the mode switches that moved (COORD at run start, FREE or TELEOP at run end, no abort from a mode change).
mode() sends nothing to task any more; it sets the page the user interface shows. The wait_complete() after it waited on whatever command came before, and while a program runs or is paused task does not report DONE, so each one sat out its timeout: AXIS hung for 5 s on a spindle button while paused (ensure_mode()). Remove the wait after every mode() call in the user interfaces, their libraries and the sample configs: AXIS, gmoccapy, gscreen and the silverdragon skin, touchy, pyui, GStat, the gladevcp and qtvcp actions, the gladevcp offset page and probe panels, the 3pcenter panel. The waits after teleop_enable() that follow some of them stay.
The task mode follows what task runs, and nothing sets it any more: task accepted EMC_TASK_SET_MODE and did nothing, and the Python, Tcl and linuxcncrsh mode commands stopped sending it. - NML: drop EMC_TASK_SET_MODE (type 504) and task's handling of it. - shcom: drop sendManual(), sendAuto() and sendMdi(); schedrmt and emclcd no longer switch modes before MDI or opening a program, and emclcd's Test key no longer toggles the mode. - halui: drop halui.mode.manual, .auto and .mdi. The .is-* status pins stay. - Users of the pins: the xhc-hb04 pendant helper starts a program with halui.program.run only, the halui_pyvcp sim panel keeps the mode LEDs, the xhc-whb04b-6 example configuration and docs drop their mode nets, the remote start example needs halui.program.run only.
When the last MDI command finished, task reported DONE in the cycle before the run ended, and again before motion was back in joint or world mode. A client waiting for DONE could then see coordinated mode, or have an axis jog refused: linuxcncrsh's test read TELEOP_ENABLE OFF after its MDI commands on CI. Task now reports DONE only when no run is on and motion is in the mode the run went back to (with a 1 s timeout should motion not get there). tests/task-modeless checks that motion is in world mode as soon as an MDI command is DONE, and that a jog right after is accepted.
GStat gets is_jog_ok(), is_spindle_ok(), is_pause_jog_ok() and a pause-jog-ok-changed signal. Jog and spindle action buttons use them, STOP_JOG works while paused, and UPDATE_VAR_FILE saves the parameter file with task_plan_synch() instead of a mode change.
Show the jog page while jogs during a pause are possible and restore the previous page on resume or abort.
Don't switch to teleop while paused. Gscreen makes its mode and axis buttons sensitive while paused and returns to the paused mode on resume.
Use STATUS.is_jog_ok() in kb_jog and only switch to manual mode when not jogging during a pause.
… modes The planner table has one idle situation instead of Manual, MDI and Auto idle. stale-motion-status no longer waits for coordinated mode after mode(AUTO), and jog-while-paused reads task.mode.is-manual.
In position is the planner's. The joints follow it through the cubic interpolators and arrive a few cycles later. Since mode changes are deferred instead of dropped, the change to joint mode happened on the first in-position cycle and took pos_cmd mid-spline, so an MDI move from joint mode ended up to 0.0003 mm off its target in about 1 run in 100. Wait until the last four points of each joint's cubic are the same. A moving external offset never rests, so it does not hold the change up.
The save was dropped by looking at task_paused, which a program that ends normally leaves set: after stepping a program to its end, a paused MDI command would have resumed with that program's coolant. taskRunEnd() clears it, as on the modeless branches.
tests/task-planner and test_task_probe recorded what the planner did with every command, to show that the refactoring of emcTaskPlan() changed nothing. That work is done.
Contributor
|
I think this should be split now that the modeless work is in it:
Still open from my earlier list: |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
This is the first step towards removing halui: task exports the halui pins
that motion and iocontrol don't already have, as a HAL component
taskwith halui's pin names under
task.. Overrides, MDI commands, jogging andjoint/axis selection follow in later PRs; halui is untouched here and keeps
working.
The first three commits are groundwork with no change in behaviour, and the
first one is what shows that.
Commits
tests/task-plannerbrings task into each situation the planner tellsapart (E-stop, off, Manual, MDI idle and running, Auto idle, reading,
waiting, paused) and sends it every command
emcTaskPlan()handles, oneat a time. From task's own debug output it records whether the planner
issued the command, queued it, refused it or handled it itself, and what
situation the command left task in.
expectedis today's behaviour, so achange to the planner either leaves the table alone or shows up as a diff
of it. The commands come from
test_task_probe, a small NML client builtfor run-in-place only (not installed; the test skips without it). About
a minute. It is scaffolding for the refactoring of task that follows
(this PR and the modeless task); once that is done, the test and
test_task_probeare removed again.The main loop decides whether there is a new command and passes it, or
NULL; the planner no longer reads the NML buffer itself. This is what
lets a command reach the planner another way. Table unchanged.
The eight tables repeated the commands each passes straight to
emcTaskIssueCommand().isImmediate()says this once, by state, modeand interpreter state; each table keeps only what is special to it and
its refusal message. 256 lines shorter. Table unchanged; letting spindle
orient through in Manual, as an example of a slip, fails the test.
The
taskcomponent and its status pins (table below).task.tool.diameterreads the loaded tool's entry from the status, as halui does since
7412d9d, so task's pins need no tool table access. Updated once per
task cycle from task's own status, so current in the same cycle where
halui's lag by its poll. The component is created before
inihalisready, because the linuxcnc script runs the HAL files as soon as it is:
HAL files can connect
task.*pins, as they can halui's.tests/task-hal-pinsconnects some in a HAL file and compares every onewith halui's pin in Manual, teleop, MDI with offsets and tools, with
overrides, and while a program runs and is paused.
The command inputs. Like halui's they act on the rising edge and send
the same commands, but not through NML:
emcTaskQueueInternalCommand()queues them and the main loop hands one to
emcTaskPlan()on each cyclewithout a new NML command. They leave the echo serial number alone, a
refused one is reported on the error channel only, and none of them
changes the status of the UI's last command.
tests/task-hal-inputspulses each pin without halui and checks both.
task.estop.is-activated(iocontrol's is inverted),task.estop.activate(iocontrol's is a level, not an edge) and
task.tool.number(iocontrol'sis signed). With these, a configuration can be moved off halui's covered
pins by renaming alone.
Every commit builds and passes the task, halui, abort, linuxcncrsh,
mdi-queue and toolchanger tests on its own.
Difference from halui
No
task.mode.manual/.auto/.mdi: task's mode is to follow whattask runs rather than be set (the modeless task work).
task.program.runswitches to Auto first, as halui does.
Found along the way
#4831: after a tool command in Manual or MDI, task's wait flag stays set and
MDI commands are queued instead of issued until a program runs. The planner
test clears the flag before each situation so that no cell depends on
earlier probes; the behaviour itself is left as it is here.
halui's pins and where they go
✅ the same signal already exists elsewhere · ◐ partly, or with different
semantics · ❌ nothing. The last column is the
task.*pin from this PR, orwhere the rest is planned to go.
Status outputs
halui.machine.is-onmotion.motion-enabledhalui.machine.units-per-mmtask.machine.units-per-mmhalui.estop.is-activatediocontrol.0.user-enable-out(inverted)task.estop.is-activatedhalui.mode.is-manualtask.mode.is-manualhalui.mode.is-autotask.mode.is-autohalui.mode.is-mditask.mode.is-mdihalui.mode.is-teleopmotion.teleop-modehalui.mode.is-jointmotion.teleop-mode/motion.coord-modeboth falsetask.mode.is-jointhalui.mist.is-oniocontrol.0.coolant-misthalui.flood.is-oniocontrol.0.coolant-floodhalui.program.is-idletask.program.is-idlehalui.program.is-runningtask.program.is-runninghalui.program.is-pausedtask.program.is-pausedhalui.program.optional-stop.is-ontask.program.optional-stop.is-onhalui.program.block-delete.is-ontask.program.block-delete.is-onhalui.halui-mdi-is-runninghalui.max-velocity.valuetask.max-velocity.valuehalui.feed-override.valuetask.feed-override.valuehalui.rapid-override.valuetask.rapid-override.valuehalui.spindle.S.is-onspindle.S.onhalui.spindle.S.runs-forwardspindle.S.forwardhalui.spindle.S.runs-backwardspindle.S.reversehalui.spindle.S.brake-is-onspindle.S.brakehalui.spindle.S.override.valuetask.spindle.S.override.valuehalui.joint.N.is-homedjoint.N.homedhalui.joint.N.has-faultjoint.N.faultedhalui.joint.N.on-hard-min-limitjoint.N.neg-hard-limithalui.joint.N.on-hard-max-limitjoint.N.pos-hard-limithalui.joint.N.on-soft-min-limitmotion.on-soft-limit(global only)task.joint.N.on-soft-min-limithalui.joint.N.on-soft-max-limitmotion.on-soft-limit(global only)task.joint.N.on-soft-max-limithalui.joint.N.override-limitstask.joint.N.override-limitshalui.joint.N.is-selectedhalui.joint.selectedhalui.joint.selected.{is-homed,has-fault,on-*-limit,override-limits}halui.axis.L.is-selectedhalui.axis.selectedhalui.axis.L.pos-commandedaxis.L.pos-cmdhalui.axis.L.pos-feedbackjoint.N.pos-fb)task.axis.L.pos-feedbackhalui.axis.L.pos-relativetask.axis.L.pos-relativehalui.tool.numberiocontrol.0.tool-number(s32)task.tool.numberhalui.tool.length_offset.{x..w}motion.tooloffset.{x..w}halui.tool.diametertask.tool.diameterCommand inputs
halui.machine.on/.offtask.machine.on/.offhalui.estop.activateiocontrol.0.emc-enable-inlow (a level that holds E-stop, not an edge)task.estop.activatehalui.estop.resettask.estop.resethalui.mode.manual/.auto/.mdihalui.mode.teleop/.jointtask.mode.teleop/.jointhalui.mist.on/.offtask.mist.on/.offhalui.flood.on/.offtask.flood.on/.offhalui.program.runtask.program.runhalui.program.pause/.resumemotion.feed-hold(needs M53) /motion.feed-inhibit— motion-level hold, not a task pausetask.program.pause/.resumehalui.program.steptask.program.stephalui.program.stoptask.program.stophalui.abortmotion.jog-stoponly stops jogs)task.aborthalui.program.optional-stop.on/.offtask.program.optional-stop.on/.offhalui.program.block-delete.on/.offtask.program.block-delete.on/.offhalui.home-alltask.home-all(only with[JOINT_0]HOME_SEQUENCE, like halui)halui.joint.N.home/.unhometask.joint.N.home/.unhomehalui.joint.selected.home/.unhomehalui.mdi-command-NNhalui.max-velocity.{counts,count-enable,direct-value,scale,increase,decrease}ini.traj_max_velocity(changes the limit, not the runtime value)halui.feed-override.{counts,count-enable,direct-value,scale,increase,decrease,reset}motion.adaptive-feed(scales feed, but invisible to GUIs, not an override)halui.rapid-override.{counts,count-enable,direct-value,scale,increase,decrease,reset}halui.spindle.S.override.{counts,count-enable,direct-value,scale,increase,decrease,reset}halui.spindle.S.start/.stopspindle.S.inhibitcan only block)task.spindle.S.start/.stophalui.spindle.S.forward/.reversetask.spindle.S.forward/.reversehalui.spindle.S.increase/.decreasetask.spindle.S.increase/.decreasehalui.spindle.S.brake-on/.brake-offtask.spindle.S.brake-on/.brake-offhalui.joint.N.selecthalui.axis.L.selecthalui.joint.N.plus/.minushalui.joint.N.analoghalui.joint.N.increment+.increment-plus/.increment-minusjoint.N.jog-counts+jog-scale+jog-enable(wheel jog; a pulse per press ≈ increment)halui.joint.selected.{plus,minus,increment,increment-plus,increment-minus}halui.joint.jog-speed/.jog-deadbandhalui.axis.L.plus/.minushalui.axis.L.analoghalui.axis.L.increment+.increment-plus/.increment-minusaxis.L.jog-counts+jog-scale+jog-enablehalui.axis.selected.{plus,minus,increment,increment-plus,increment-minus}halui.axis.jog-speed/.jog-deadband